#include <iostream>
using namespace std;

// void test1 ()
// {
// 	int i = 1;
// 	// 隐式类型转换
// 	// double d = i;
//     double d = static_cast<double> (i);
//     // double d = reinterpret_cast<double> (i);
// 	printf("%d, %.2f\n" , i, d);
// 	int* p = &i; 
// 	// 显示的强制类型转换
// 	// int address = (int) p; 
//     // int addr = reinterpret_cast<int> (p);
// 	// printf("%x, %d\n" , p, addr);
// }

// void test2()
// {
// 	double d = 12.34;
//     // 相关类型，使用隐式类型转换
// 	int a = static_cast<int>(d);
// 	cout << a << endl;
//     // 不相关类型，必须使用显示类型转换
//     // int *p = (int*)a; // C
// 	// 这里使用static_cast会报错，应该使用reinterpret_cast
// 	// int *p = static_cast<int*>(a);
// 	int *p = reinterpret_cast<int*>(a); // C++
//     cout << p << endl;
// }

// void test3 ()
// {
// 	volatile const int a = 2;
//     // 删除变量的const属性，必须使用显示类型转换
//     // int* p = (int*)&a; // C
// 	int* p = const_cast<int*>(&a); // C++
// 	*p = 3;
// 	cout<< a << endl; //这里会输出3吗？
// }

// // int main()
// // {
// //     test3();
// //     return 0;
// // }

// class A
// {
// public :
//     int _a = 10;
// 	virtual void f(){}
// };

// class B : public A
// {
// public:
//     int _b = 20;
// };

// void fun1 (A* pa)
// {
// 	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
// 	B* pb1 = static_cast<B*>(pa);
// 	B* pb2 = dynamic_cast<B*>(pa);
// 	cout<<"pb1:" <<pb1<< endl;
// 	cout<<"pb2:" <<pb2<< endl;
// }

// void fun2 (B* pb)
// {
// 	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
// 	A* pa1 = static_cast<A*>(pb);
// 	A* pa2 = dynamic_cast<A*>(pb);
// 	cout<<"pa1:" <<pa1<< endl;
// 	cout<<"pa2:" <<pa2<< endl;
// }

// int main ()
// {
// 	// A a;
// 	// B b;
//     // A* pa = &b;
//     // // B* pb = (B*)&a;
//     // // B* pb = static_cast<B*>(&a);
//     // // B* pb = reinterpret_cast<B*>(&a);
//     // A& ra = b;
//     // // B& rb = (B&)a;
//     // // B& rb = static_cast<B&>(a);
//     // // B& rb = reinterpret_cast<B&>(a);
//     // a = b;
//     // // b = (B)a;
//     // // b = static_cast<B>(a);
//     // // b = reinterpret_cast<B>(a);
//     // cout << a._a << ":" << b._b << endl;
//     // cout << pa->_a << ":" << pb->_a << endl;
//     // cout << ra._a << ":" << rb._a << endl;
//     // cout << a._a << ":" << b._b << endl;

// 	A a;
// 	B b;
// 	// fun2(&a);
// 	cout << endl;
// 	fun2(&b);
// 	return 0;
// }

// #include <iostream>
// #include <string>
// using namespace std;
// int main()
// {
// 	string s;
// 	cin >> s;          //输入："hello world"
// 	cout << s << endl; //输出："hello"
//     getline(cin, s);   //输入："hello world"
//     cout << s << endl; //输出："hello world"
// 	return 0;
// }

// #include <stdio.h>
// #include <stdlib.h>

// int main()
// {
// 	int n = 123456789;
// 	// char s1[32];
// 	// itoa(n, s1, 10);
 
// 	char s2[32];
// 	sprintf(s2, "%d", n);
// 	char s3[32];
// 	sprintf(s3, "%f", n);
// 	cout << s2 << endl;
// 	cout << s3 << endl;
// 	return 0;
// }


// #include<sstream>
// int main()
// {
// 	int a = 12345678;
// 	string sa;
// 	// 将一个整形变量转化为字符串，存储到string类对象中
// 	stringstream s;
// 	s << a;
// 	s >> sa;
// 	cout << sa << endl;
 
// 	// clear()
// 	// 注意多次转换时，必须使用clear将上次转换状态清空掉
// 	// stringstreams在转换结尾时(即最后一个转换后),会将其内部状态设置为badbit
// 	// 因此下一次转换是必须调用clear()将状态重置为goodbit才可以转换
// 	// 但是clear()不会将stringstreams底层字符串清空掉
// 	// s.str("");
// 	// 将stringstream底层管理string对象设置成"",
// 	// 否则多次转换时，会将结果全部累积在底层string对象中
 
// 	s.str("");
// 	// s.clear(); // 清空s, 不清空会转化失败
// 	double d = 12.34;
// 	s << d;
// 	s >> sa;
// 	cout << sa << endl;
 
// 	string sValue;
// 	sValue = s.str(); // str()方法：返回stringsteam中管理的string类型
// 	cout << sValue << endl;
 
// 	return 0;
// }

// int main()
// {
// 	stringstream sstream;
// 	// 将多个字符串放入 sstream 中
// 	sstream << "first" << " " << "string,";
// 	sstream << " second string";
// 	cout << "strResult is: " << sstream.str() << endl;
// 	// 清空 sstream
// 	sstream.str("");
// 	sstream << "third string";
// 	cout << "After clear, strResult is: " << sstream.str() << endl;
// 	return 0;
// }

// #include <sstream>
// struct ChatInfo
// {
// 	string _name; // 名字
// 	int _id; // id
// 	string _msg; // 聊天信息
// };
// int main()
// {
// 	// 结构信息序列化为字符串
// 	ChatInfo winfo = { "张三", 135246, "看电影吧"};
// 	ostringstream oss;
// 	oss << winfo._name << " " << winfo._id << " "<< winfo._msg;
// 	string str = oss.str();
// 	cout << str << endl << endl;
// 	// 我们通过网络这个字符串发送给对象，实际开发中，信息相对更复杂，
// 	// 一般会选用Json、xml等方式进行更好的支持
// 	// 字符串解析成结构信息
// 	ChatInfo rInfo;
// 	istringstream iss(str);
// 	iss >> rInfo._name >> rInfo._id >> rInfo._msg;
// 	cout << "-------------------------------------------------------"
// 		<< endl;
// 	cout << "姓名：" << rInfo._name << "(" << rInfo._id << ") " << endl;
// 	cout << rInfo._name << ":>" << rInfo._msg << endl;
// 	cout << "-------------------------------------------------------"
// 		<< endl;
// 	return 0;
// }


// int main()
// {
// 	cout << "cout" << endl;
// 	cerr << "cerr" << endl;
// 	clog << "clog" << endl;
// 	return 0;
// }

class A
{
	int _a;
public:
	// 单参构造函数支持隐式类型转换
	A(int a = 0)
	:_a(a)
	{}
	// 重载一个operator int，支持自定义类型转内置类型
	operator int() const //可以加explicit，必须要求强转
	{
		return _a;
	}
};

int main()
{
	// 内置类型转自定义类型
	A aa1 = 1;
	A aa2 = static_cast<A>(1);
	// 自定义类型转内置类型
	int x1 = aa1;
	int x2 = static_cast<int>(aa1);
	
}